import numpy as np
import pandas as pd
from mlxtend.frequent_patterns import apriori
from mlxtend.preprocessing import TransactionEncoder
from mlxtend.frequent_patterns import association_rules
import statisticAnalysis as sa


def occ_rating(md):
    md = sa.unpack_ratings(md)
    or_df = md[['speaker_occupation', 'maximum_rating']].astype(str)
    or_array = np.array(or_df)
    or_list = or_array.tolist()

    te = TransactionEncoder()
    df_tf = te.fit_transform(or_list)
    df = pd.DataFrame(df_tf, columns=te.columns_)
    frequent_itemsets = apriori(df, min_support=0.001, use_colnames=True)  # use_colnames=True表示使用元素名字，默认的False使用列名代表元素
    frequent_itemsets.sort_values(by='support', ascending=False, inplace=True)  # 频繁项集可以按支持度排序
    print(frequent_itemsets[frequent_itemsets.itemsets.apply(lambda x: len(x)) == 2])  # 选择长度 ==2 的频繁项集
    association_rule = association_rules(frequent_itemsets, metric='confidence',
                                         min_threshold=0.5)  # metric可以有很多的度量选项，返回的表列名都可以作为参数
    association_rule.sort_values(by='leverage', ascending=False, inplace=True)  # 关联规则可以按leverage排序
    print(association_rule)


def occ_tag(md):
    md = sa.unpack_tags(md)
    ot_df = md[['speaker_occupation', 'tags']]
    ot_list = ot_df.values.tolist()
    ot_list_pre = []
    for i in range(len(ot_list)):
        for j in range(len(ot_list[i][1])):
            ot_list_pre.append([str(ot_list[i][0]), str(ot_list[i][1][j])])

    te = TransactionEncoder()
    df_tf = te.fit_transform(ot_list_pre)
    df = pd.DataFrame(df_tf, columns=te.columns_)
    frequent_itemsets = apriori(df, min_support=0.0008, use_colnames=True)  # use_colnames=True表示使用元素名字，默认的False使用列名代表元素
    frequent_itemsets.sort_values(by='support', ascending=False, inplace=True)  # 频繁项集可以按支持度排序
    print(frequent_itemsets[frequent_itemsets.itemsets.apply(lambda x: len(x)) == 2])  # 选择长度 ==2 的频繁项集
    association_rule = association_rules(frequent_itemsets, metric='confidence',
                                         min_threshold=0.1)  # metric可以有很多的度量选项，返回的表列名都可以作为参数
    association_rule.sort_values(by='leverage', ascending=False, inplace=True)  # 关联规则可以按leverage排序
    print(association_rule)


def tag_views(md):
    md = sa.unpack_tags(md)
    tv_df = md[['tags', 'views_level']]
    tv_list = tv_df.values.tolist()
    tv_list_pre = []
    for i in range(len(tv_list)):
        for j in range(len(tv_list[i][0])):
            tv_list_pre.append([str(tv_list[i][0][j]), str(tv_list[i][1])])

    te = TransactionEncoder()
    df_tf = te.fit_transform(tv_list_pre)
    df = pd.DataFrame(df_tf, columns=te.columns_)
    frequent_itemsets = apriori(df, min_support=0.01, use_colnames=True)  # use_colnames=True表示使用元素名字，默认的False使用列名代表元素
    frequent_itemsets.sort_values(by='support', ascending=False, inplace=True)  # 频繁项集可以按支持度排序
    print(frequent_itemsets[frequent_itemsets.itemsets.apply(lambda x: len(x)) == 2])  # 选择长度 ==2 的频繁项集
    association_rule = association_rules(frequent_itemsets, metric='confidence',
                                         min_threshold=0.1)  # metric可以有很多的度量选项，返回的表列名都可以作为参数
    association_rule.sort_values(by='leverage', ascending=False, inplace=True)  # 关联规则可以按leverage排序
    print(association_rule)


def tag_comments(md):
    md = sa.unpack_tags(md)
    tv_df = md[['tags', 'comments_level']]
    tv_list = tv_df.values.tolist()
    tv_list_pre = []
    for i in range(len(tv_list)):
        for j in range(len(tv_list[i][0])):
            tv_list_pre.append([str(tv_list[i][0][j]), str(tv_list[i][1])])

    te = TransactionEncoder()
    df_tf = te.fit_transform(tv_list_pre)
    df = pd.DataFrame(df_tf, columns=te.columns_)
    frequent_itemsets = apriori(df, min_support=0.01, use_colnames=True)  # use_colnames=True表示使用元素名字，默认的False使用列名代表元素
    frequent_itemsets.sort_values(by='support', ascending=False, inplace=True)  # 频繁项集可以按支持度排序
    print(frequent_itemsets[frequent_itemsets.itemsets.apply(lambda x: len(x)) == 2])  # 选择长度 ==2 的频繁项集
    association_rule = association_rules(frequent_itemsets, metric='confidence',
                                         min_threshold=0.1)  # metric可以有很多的度量选项，返回的表列名都可以作为参数
    association_rule.sort_values(by='leverage', ascending=False, inplace=True)  # 关联规则可以按leverage排序
    print(association_rule)

def rating_views(md):
    md = sa.unpack_ratings(md)
    or_df = md[['maximum_rating', 'views_level']].astype(str)
    or_array = np.array(or_df)
    or_list = or_array.tolist()

    te = TransactionEncoder()
    df_tf = te.fit_transform(or_list)
    df = pd.DataFrame(df_tf, columns=te.columns_)
    frequent_itemsets = apriori(df, min_support=0.1, use_colnames=True)  # use_colnames=True表示使用元素名字，默认的False使用列名代表元素
    frequent_itemsets.sort_values(by='support', ascending=False, inplace=True)  # 频繁项集可以按支持度排序
    print(frequent_itemsets[frequent_itemsets.itemsets.apply(lambda x: len(x)) == 2])  # 选择长度 ==2 的频繁项集
    association_rule = association_rules(frequent_itemsets, metric='confidence',
                                         min_threshold=0.3)  # metric可以有很多的度量选项，返回的表列名都可以作为参数
    association_rule.sort_values(by='leverage', ascending=False, inplace=True)  # 关联规则可以按leverage排序
    print(association_rule)
